package com.tecniplast.selene.common.util;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
	  /**
     * 缺省的日期显示格式： yyyy-MM
     */
    public static final String YEAR_MONTH = "yyyyMM";

    /**
     * 缺省的日期显示格式： yyyy-MM-dd
     */
    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    /**
     * 缺省的日期时间显示格式：yyyy-MM-dd HH:mm:ss
     */
    public static final String DEFAULT_DATETIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    /**
     * 缺省时间显示格式：HH:mm:ss
     */
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

    /**
     * 取得当前日期以后若干天的日期。如果要得到以前的日期，参数用负数。 例如要得到上星期同一天的日期，参数则为-7
     * @param days 增加的日期数
     * @return 增加以后的日期
     */
    public static Date addDays(int days) {
        return addDays(getNow(), days);
    }
    /**  * 得到某个日期的后一天日期  
     * * @param d  
     * * @return  
     * 
     * */ 
    public static String getAfterDate(String d){
    	Calendar c = Calendar.getInstance(); 
    	Date date=null; 
    	try { 
    	date = new SimpleDateFormat("yy-MM-dd").parse(d); 
    	} catch (ParseException e) { 
    	e.printStackTrace(); 
    	} 
    	c.setTime(date); 
    	int day=c.get(Calendar.DATE); 
    	c.set(Calendar.DATE,day+1); 

    	String dayAfter=new SimpleDateFormat("yyyy-MM-dd").format(c.getTime()); 
    	return dayAfter; 
    }
    /**  * 得到某个日期的下个月1号  
     * * @param d  
     * * @return  
     * 
     * */ 
    public static String getAfterMonth(String d){
    	Calendar c = Calendar.getInstance(); 
    	String dtemp = d.substring(0,d.length()-2)+"01";
    	Date date=null; 
    	try { 
    	date = new SimpleDateFormat("yy-MM-dd").parse(dtemp); 
    	} catch (ParseException e) { 
    	e.printStackTrace(); 
    	} 
    	c.setTime(date); 
    	int month=c.get(Calendar.MONTH); 
    	c.set(Calendar.MONTH,month+1); 

    	String dayAfter=new SimpleDateFormat("yyyy-MM-dd").format(c.getTime()); 
    	return dayAfter; 
    }
   /* public static void main(String[] args) {
		System.out.println(getAfterMonth("2014-12-31"));
		
	}*/
    /**  * 得到某个日期的前一天日期  
     * * @param d  
     * * @return  
     * 
     * */ 
    public static String getBeforeDate(String d){
    	Calendar c = Calendar.getInstance(); 
    	Date date=null; 
    	try { 
    	date = new SimpleDateFormat("yy-MM-dd").parse(d); 
    	} catch (ParseException e) { 
    	e.printStackTrace(); 
    	} 
    	c.setTime(date); 
    	int day=c.get(Calendar.DATE); 
    	c.set(Calendar.DATE,day-1); 

    	String dayAfter=new SimpleDateFormat("yyyy-MM-dd").format(c.getTime()); 
    	return dayAfter; 
    }
    /**
     * 取得当前日期以后某月的日期。如果要得到以前月份的日期，参数用负数。
     * @param months 增加的月份数
     * @return 增加以后的日期
     */
    public static Date addMonths(int months) {
        return addMonths(getNow(), months);
    }

    /**
     * 取得当前日期以后某年的日期。如果要得到以前月份的日期，参数用负数。
     * @param months
     * @return
     */
    public static Date addYears(int years) {
        return addYears(getNow(), years);
    }

    /**
     * 计算两个日期相差天数。 用第一个日期减去第二个。如果前一个日期小于后一个日期，则返回负数
     * 
     * @param one
     *            第一个日期数，作为基准
     * @param two
     *            第二个日期数，作为比较
     * @return 两个日期相差天数
     */
    public static long diffDays(Date one, Date two) {
        return (one.getTime() - two.getTime()) / (24 * 60 * 60 * 1000);
    }

    /**
     * 计算两个日期相差月份数 如果前一个日期小于后一个日期，则返回负数
     * @param one
     *            第一个日期数，作为基准
     * @param two
     *            第二个日期数，作为比较
     * @return 两个日期相差月份数
     */
    public static int diffMonths(Date one, Date two) {
        Calendar calendar = Calendar.getInstance();
        // 得到第一个日期的年分和月份数
        calendar.setTime(one);
        int yearOne = calendar.get(Calendar.YEAR);
        int monthOne = calendar.get(Calendar.MONDAY);
        // 得到第二个日期的年份和月份
        calendar.setTime(two);
        int yearTwo = calendar.get(Calendar.YEAR);
        int monthTwo = calendar.get(Calendar.MONDAY);
        return (yearOne - yearTwo) * 12 + (monthOne - monthTwo);
    }

    /**
     * 格式化 日期串 “2005年10月1日”
     * @return
     */
    public static String formatDate(String dateStr) throws Exception {

        if (dateStr == null || dateStr.trim().length() == 0) {
            return "";
        }

        Date date = parse(dateStr.trim().substring(0, 10), "yyyy-MM-dd");
            SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
            return df.format(date);

    }
    
    /**
     * [util包中的date转成sql包中date]
     * @param date
     * @return
     */
    public static java.sql.Date toSqlDate(java.util.Date date){
        if (date == null) {
            return null;
        }else {
            return new java.sql.Date(date.getTime());
        }
    }
    
    /**
     * [sql包中的date转成util包中date]
     * @param date
     * @return
     */
    public static java.util.Date toUtilDate(java.sql.Date date){
        if (date == null) {
            return null;
        }else {
            return new java.util.Date(date.getTime());
        }
    }
    /**
     * <p>Description: 得到当前日期后或前某一天</p>
     * @param pattern
     * @param days
     * @return
     */
    public static String getAddDateTime(String pattern, int days) {
        Date datetime = addDays(days);
        return getDateTime(datetime, pattern);
    }
    /**
     * 
     * [获得当前日期+时间]
     * @return
     */
    public static Date getCurrentDate(){
        return Calendar.getInstance().getTime();
    }
    /**
     * 得到当前日
     * @return 当前日
     */
    public static int getCurrentDay() {
        return Calendar.getInstance().get(Calendar.DATE);
    }

    /**
     * 得到当前小时
     * @return 当前小时
     */
    public static int getCurrentHour() {
        return Calendar.getInstance().get(Calendar.HOUR_OF_DAY);

    }

    /**
     * 得到当前分钟
     * @return 当前分钟
     */
    public static int getCurrentMinute() {
        return Calendar.getInstance().get(Calendar.MINUTE);
    }

    /**
     * 得到当前月份
     * @return 当前月份
     */
    public static int getCurrentMonth() {
        // 用get得到的月份数比实际的小1，需要加上
        return Calendar.getInstance().get(Calendar.MONTH) + 1;
    }

    /**
     * 得到当前秒
     * 
     * @return 当前秒
     */
    public static int getCurrentSecond() {
        return Calendar.getInstance().get(Calendar.SECOND);

    }

    /**
     * 得到当前年份
     * 
     * @return 当前年份
     */
    public static int getCurrentYear() {
        return Calendar.getInstance().get(Calendar.YEAR);
    }

    /**
     * 得到用缺省方式格式化的当前日期
     * 
     * @return 当前日期
     */
    public static String getDate() {
        return getDateTime(DEFAULT_DATE_FORMAT);
    }
    /**
     * 得到用缺省方式格式化的当前年月
     * 
     * @return 当前日期
     */
    public static Integer getYearMonth() {
    	DateFormat df = new SimpleDateFormat(YEAR_MONTH);
        String date = df.format(new Date());
        return Integer.parseInt(date);
    }

    /**
     * 得到指定日期日
     * 
     * @return 日
     */
    public static int getDateDay(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.DATE);
    }

    /**
     * 得到指定小时
     * 
     * @return 指定小时
     */
    public static int getDateHour(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.HOUR_OF_DAY);

    }

    /**
     * 得到指定分钟
     * 
     * @return 指定分钟
     */
    public static int getDateMinute(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.MINUTE);
    }

    /**
     * 得到指定日期月份
     * 
     * @return 月份
     */
    public static int getDateMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.MONTH) + 1;
    }

    /**
     * 得到当前日期，不带小时分秒
     * 
     * @return 当前日期
     */
    public static Date getDateObj() {
        DateFormat df = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
        Date date = null;
        try {
            date = df.parse(getDate());
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 得到指定秒
     * 
     * @return 指定秒
     */
    public static int getDateSecond(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.SECOND);

    }

    /**
     * 根据日期类型获取字符串类型
     * 
     * @param date
     * @return 得到的格式为 "yyyy-MM-dd"
     */
    public static String getDateString(Date date) {
        String str_date = null;
        int year = getDateYear(date);
        int motnh = getDateMonth(date);
        int day = getDateDay(date);
        if (day > 9) {
            str_date = String.valueOf(year) + "-" + String.valueOf(motnh) + "-" + String.valueOf(day);
        } else {
            str_date = String.valueOf(year) + "-" + String.valueOf(motnh) + "-0" + String.valueOf(day);
        }
        return str_date;

    }

    /**
     * 得到用缺省方式格式化的当前日期及时间
     * 
     * @return 当前日期及时间
     */
    public static String getDateTime() {
        return getDateTime(DEFAULT_DATETIME_FORMAT);
    }

    /**
     * 得到用指定方式格式化的日期
     * 
     * @param date
     *            需要进行格式化的日期
     * @param pattern
     *            显示格式
     * @return 日期时间字符串
     */
    public static String getDateTime(Date date, String pattern) {
        if (null == pattern || "".equals(pattern)) {
            pattern = DEFAULT_DATETIME_FORMAT;
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
        return dateFormat.format(date);
    }

    /**
     * 得到系统当前日期及时间，并用指定的方式格式化
     * 
     * @param pattern
     *            显示格式
     * @return 当前日期及时间
     */
    public static String getDateTime(String pattern) {
        Date datetime = Calendar.getInstance().getTime();
        return getDateTime(datetime, pattern);
    }

    /**
     * 得到指定日期年份
     * 
     * @return 年份
     */
    public static int getDateYear(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.YEAR);
    }

    /**
     * 返回本月的第一天
     * 
     * @return 本月第一天的日期
     */
    public static Date getMonthFirstDay() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), 1);
        return calendar.getTime();
    }

    /**
     * 返回本月的最后一天
     * 
     * @return 本月最后一天的日期
     */
    public static Date getMonthLastDay() {
        return getMonthLastDay(getNow());
    }

    /**
     * 返回给定日期中的月份中的最后一天
     * 
     * @param date
     *            基准日期
     * @return 该月最后一天的日期
     */
    public static Date getMonthLastDay(Date date) {

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);

        // 将日期设置为下一月第一天
        calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH) + 1, 1);

        // 减去1天，得到的即本月的最后一天
        calendar.add(Calendar.DATE, -1);

        return calendar.getTime();
    }

    /**
     * 得到系统当前日期时间
     * 
     * @return 当前日期时间
     */
    public static Date getNow() {
        return Calendar.getInstance().getTime();
    }

    /**
     * 得到当前为星期几,1-星期日,2-星期一....,7-星期六;
     * 
     * @return int 得到当前为星期几,1-星期日,2-星期一....,7-星期六;
     */
    public static int getNowWeek() {
        return Calendar.getInstance().get(Calendar.DAY_OF_WEEK);
    }

    /**
     * 获取当前月上月的最后一天
     * 
     * @param args
     */
    public static Date getPreMonthLastDay() {
        return getMonthLastDay(addMonths(-1));

    }


    /**
     * 根据日期返回是星期几
     * 
     * @param day
     *            1-星期日,2-星期一....,7-星期六;
     * @return 星期日,星期一....,星期六;
     */
    public static String getWeekDay(int day) {
        String week = "";
        switch (day) {
            case 2:
                week = "星期一";
                break;
            case 3:
                week = "星期二";
                break;
            case 4:
                week = "星期三";
                break;
            case 5:
                week = "星期四";
                break;
            case 6:
                week = "星期五";
                break;
            case 7:
                week = "星期六";
                break;
            default:
                week = "星期日";
                break;
        }
        return week;
    }

    /**
     * <p>Description: 判断时间date1是否在时间date2之前,时间格式 2005-4-21 16:16:34</p>
     * @param date1
     * @param date2
     * @return
     */
    public static boolean isDateBefore(String date1, String date2) {
        try {
            DateFormat df = DateFormat.getDateTimeInstance();
            boolean flag = df.parse(date1).before(df.parse(date2));
            return flag;
        } catch (ParseException e) {
            System.out.print("[SYS] " + e.getMessage());
            return false;
        }
    }

    /**
     * 将一个字符串用给定的格式转换为日期类型。 <br>
     * 注意：如果返回null，则表示解析失败
     * 
     * @param datestr
     *            需要解析的日期字符串
     * @param pattern
     *            日期字符串的格式，默认为“yyyy-MM-dd”的形式
     * @return 解析后的日期
     */
    public static Date parse(String datestr, String pattern) {
        Date date = null;

        if (null == pattern || "".equals(pattern)) {
            pattern = DEFAULT_DATE_FORMAT;
        }
        if (datestr == null || datestr.trim().length() == 0) {
            return date;
        }
        try {
            SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
            date = dateFormat.parse(datestr);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return date;
    }

    /**
     * 格式化java.sql.Date对象成字符串
     * 
     * @param obj
     * @return
     */
    public static String parseSqlDate(Object obj) {
        if (obj instanceof java.sql.Timestamp) {
            String result = obj.toString().trim();
            if (result.length() > 10) {
                result = result.substring(0, 10);
            }
            obj = java.sql.Date.valueOf(result);
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat(DEFAULT_DATE_FORMAT);
        return dateFormat.format((java.sql.Date) obj);
    }

    /**
     * 格式化java.sql.Time 对象成字符串
     * 
     * @param obj
     * @return
     */
    public static String parseSqlTime(Object obj) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(DEFAULT_TIME_FORMAT);
        return dateFormat.format((java.sql.Time) obj);
    }

    /**
     * 格式化java.sql.Timestamp 对象成字符串
     * 
     * @param obj
     * @return
     */
    public static String parseSqlTimeStamp(Object obj) {
        if (obj instanceof java.sql.Date) {
            String result = obj.toString().trim();
            if (result.length() == 10) {
                result = result + " 00:00:00";
            }
            obj = java.sql.Timestamp.valueOf(result);
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat(DEFAULT_DATETIME_FORMAT);
        return dateFormat.format((java.sql.Timestamp) obj);
    }

    /**
     * 将一个字符串用给定的格式转换为字符串类型。 <br>
     * 注意：如果返回null，则表示解析失败
     * 
     * @param dateSting
     *            需要解析的日期字符串
     * @param pattern
     *            日期字符串的格式，默认为“yyyy-MM-dd”的形式
     * @return 解析后的日期
     */
    public static String parseStr(String dateSting, String pattern) {
        if (null == pattern || "".equals(pattern)) {
            pattern = DEFAULT_DATE_FORMAT;
        }
        if (dateSting == null || dateSting.trim().length() == 0) {
            return "";
        }
        if (dateSting.length() == 10) {
            dateSting = dateSting + " 00:00:00";
        }

        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
        return dateFormat.format(parse(dateSting, DEFAULT_DATETIME_FORMAT));
    }
    
    /**
     * 
     * [是用当前日期格式化字符串]
     * @param rule 待格式化的字符串
     * @return 格式化好的新字符串
     *  // 字母 日期或时间元素 表示 示例
        // G Era 标志符 Text AD
        // y 年 Year 1996; 96
        // M 年中的月份 Month July; Jul; 07
        // w 年中的周数 Number 27
        // W 月份中的周数 Number 2
        // D 年中的天数 Number 189
        // d 月份中的天数 Number 10
        // F 月份中的星期 Number 2
        // E 星期中的天数 Text Tuesday; Tue
        // a Am/pm 标记 Text PM
        // H 一天中的小时数（0-23） Number 0
        // k 一天中的小时数（1-24） Number 24
        // K am/pm 中的小时数（0-11） Number 0
        // h am/pm 中的小时数（1-12） Number 12
        // m 小时中的分钟数 Number 30
        // s 分钟中的秒数 Number 55
        // S 毫秒数 Number 978
        // z 时区 General time zone Pacific Standard Time; PST; GMT-08:00
        // Z 时区 RFC 822 time zone -0800
     */
    public static String formatWithCurrent(String rule) {
        String next = new String(rule);
        // 1、替换格式中数字变动部分；2、因为日期格式中没有大写的Y格式所以转成小写；3、因为日期格式中大写的dd表示为年中的天数，不是我们所期望的，所以转换成小写d
        next = next.replaceAll("Y", "y").replaceAll("D", "d");
        Calendar calendar = Calendar.getInstance();
        DateFormat df = new SimpleDateFormat(next);
        next = df.format(calendar.getTime());
        return next;
    }
    /**
     * 将日期格式转化成Integer类型
     */
    public static Integer toInteger(Date date){
    	String strDate = getDateTime(date,"yyyyMMdd");
    	return Integer.parseInt(strDate);
    }
    /**
     * 将yyyy-MM-dd类型的字符串转化成Integer类型
     */
    public static Integer toInteger(String date){
    	return Integer.parseInt(date.replaceAll("-", ""));
    }
    /**
     * 将Integer类型转化成日期格式
     */
    public static Date toDate(Integer date){
    	
    	return parse(String.valueOf(date), "yyyyMMdd");
    }
 // 获取当天时间
 	public static String getNowTime(String dateformat) {
 		Date now = new Date();
 		SimpleDateFormat dateFormat = new SimpleDateFormat(dateformat);// 可以方便地修改日期格式
 		String hehe = dateFormat.format(now);
 		return hehe;
 	}

 	/**
 	 * 得到二个日期间的间隔天数
 	 */
 	public static String getTwoDay(String sj1, String sj2) {
 		SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
 		long day = 0;
 		try {
 			java.util.Date date = myFormatter.parse(sj1);
 			java.util.Date mydate = myFormatter.parse(sj2);
 			day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
 		} catch (Exception e) {
 			return "";
 		}
 		return day + "";
 	}

 	/**
 	 * 根据一个日期，返回是星期几的字符串 *
 	 * 
 	 * @param sdate
 	 *            * @return
 	 */
 	public static String getWeek(String sdate) {
 		// 再转换为时间
 		Date date = strToDate(sdate);
 		Calendar c = Calendar.getInstance();
 		c.setTime(date);
 		// int hour=c.get(Calendar.DAY_OF_WEEK);
 		// hour中存的就是星期几了，其范围 1~7
 		// 1=星期日 7=星期六，其他类推
 		return new SimpleDateFormat("EEEE").format(c.getTime());
 	}

 	/**
 	 * 将短时间格式字符串转换为时间 yyyy-MM-dd *
 	 * 
 	 * @param strDate
 	 *            * @return
 	 */
 	public static Date strToDate(String strDate) {
 		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
 		ParsePosition pos = new ParsePosition(0);
 		Date strtodate = formatter.parse(strDate, pos);
 		return strtodate;
 	}

 	/**
 	 * 两个时间之间的天数 *
 	 * 
 	 * @param date1
 	 *            * @param date2 * @return
 	 */
 	public static long getDays(String date1, String date2) {
 		if (date1 == null || date1.equals(""))
 			return 0;
 		if (date2 == null || date2.equals(""))
 			return 0;
 		// 转换为标准时间
 		SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
 		java.util.Date date = null;
 		java.util.Date mydate = null;
 		try {
 			date = myFormatter.parse(date1);
 			mydate = myFormatter.parse(date2);
 		} catch (Exception e) {

 		}
 		long day = (date.getTime() - mydate.getTime()) / (24 * 60 * 60 * 1000);
 		return day;
 	}

 	// 计算当月最后一天,返回字符串
 	public static String getDefaultDay() {
 		String str = "";
 		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 		Calendar lastDate = Calendar.getInstance();
 		lastDate.set(Calendar.DATE, 1);// 设为当前月的1号
 		lastDate.add(Calendar.MONTH, 1);// 加一个月，变为下月的1号
 		lastDate.add(Calendar.DATE, -1);// 减去一天，变为当月最后一天
 		str = sdf.format(lastDate.getTime());
 		return str;
 	}

 	// 上月第一天
 	public static String getPreviousMonthFirst() {
 		String str = "";
 		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 		Calendar lastDate = Calendar.getInstance();
 		lastDate.set(Calendar.DATE, 1);// 设为当前月的1号
 		lastDate.add(Calendar.MONTH, -1);// 减一个月，变为下月的1号
 		// lastDate.add(Calendar.DATE,-1);//减去一天，变为当月最后一天
 		str = sdf.format(lastDate.getTime());
 		return str;
 	}

 	// 获取当月第一天
 	public static String getFirstDayOfMonth() {
 		String str = "";
 		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 		Calendar lastDate = Calendar.getInstance();
 		lastDate.set(Calendar.DATE, 1);// 设为当前月的1号
 		str = sdf.format(lastDate.getTime());
 		return str;
 	}

 	// 获得上月最后一天的日期
 	public static String getPreviousMonthEnd() {
 		String str = "";
 		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 		Calendar lastDate = Calendar.getInstance();
 		lastDate.add(Calendar.MONTH, -1);// 减一个月
 		lastDate.set(Calendar.DATE, 1);// 把日期设置为当月第一天
 		lastDate.roll(Calendar.DATE, -1);// 日期回滚一天，也就是本月最后一天
 		str = sdf.format(lastDate.getTime());
 		return str;
 	}

 	// 获得下个月第一天的日期
 	public static String getNextMonthFirst() {
 		String str = "";
 		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 		Calendar lastDate = Calendar.getInstance();
 		lastDate.add(Calendar.MONTH, 1);// 减一个月
 		lastDate.set(Calendar.DATE, 1);// 把日期设置为当月第一天
 		str = sdf.format(lastDate.getTime());
 		return str;
 	}

 	// 获得下个月最后一天的日期
 	public static String getNextMonthEnd() {
 		String str = "";
 		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 		Calendar lastDate = Calendar.getInstance();
 		lastDate.add(Calendar.MONTH, 1);// 加一个月
 		lastDate.set(Calendar.DATE, 1);// 把日期设置为当月第一天
 		lastDate.roll(Calendar.DATE, -1);// 日期回滚一天，也就是本月最后一天
 		str = sdf.format(lastDate.getTime());
 		return str;
 	}

 	// 获得明年最后一天的日期
 	public static String getNextYearEnd() {
 		String str = "";
 		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 		Calendar lastDate = Calendar.getInstance();
 		lastDate.add(Calendar.YEAR, 1);// 加一个年
 		lastDate.set(Calendar.DAY_OF_YEAR, 1);
 		lastDate.roll(Calendar.DAY_OF_YEAR, -1);
 		str = sdf.format(lastDate.getTime());
 		return str;
 	}

 	// 获得明年第一天的日期
 	public static String getNextYearFirst() {
 		String str = "";
 		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 		Calendar lastDate = Calendar.getInstance();
 		lastDate.add(Calendar.YEAR, 1);// 加一个年
 		lastDate.set(Calendar.DAY_OF_YEAR, 1);
 		str = sdf.format(lastDate.getTime());
 		return str;
 	}

 	// 获得本年有多少天
 	public int getMaxYear() {
 		Calendar cd = Calendar.getInstance();
 		cd.set(Calendar.DAY_OF_YEAR, 1);// 把日期设为当年第一天
 		cd.roll(Calendar.DAY_OF_YEAR, -1);// 把日期回滚一天。
 		int MaxYear = cd.get(Calendar.DAY_OF_YEAR);
 		return MaxYear;
 	}

 	public static int getYearPlus() {
 		Calendar cd = Calendar.getInstance();
 		int yearOfNumber = cd.get(Calendar.DAY_OF_YEAR);// 获得当天是一年中的第几天
 		cd.set(Calendar.DAY_OF_YEAR, 1);// 把日期设为当年第一天
 		cd.roll(Calendar.DAY_OF_YEAR, -1);// 把日期回滚一天。
 		int MaxYear = cd.get(Calendar.DAY_OF_YEAR);
 		if (yearOfNumber == 1) {
 			return -MaxYear;
 		} else {
 			return 1 - yearOfNumber;
 		}
 	}

 	// 获得本年第一天的日期
 	public static String getCurrentYearFirst() {
 		int yearPlus = getYearPlus();
 		GregorianCalendar currentDate = new GregorianCalendar();
 		currentDate.add(GregorianCalendar.DATE, yearPlus);
 		Date yearDay = currentDate.getTime();
 		DateFormat df = DateFormat.getDateInstance();
 		String preYearDay = df.format(yearDay);
 		return preYearDay;
 	}

 	// 获得本年最后一天的日期 *
 	public static String getCurrentYearEnd() {
 		Date date = new Date();
 		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy");// 可以方便地修改日期格式
 		String years = dateFormat.format(date);
 		return years + "-12-31";
 	}

 	public static String getCurrentYearMon(){
 		int year = getCurrentYear();
 		int mon = getCurrentMonth();
 		return year + "" + mon;
 	}
 	
 	// 获得上年第一天的日期 *
 	public static String getPreviousYearFirst() {
 		Date date = new Date();
 		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy");// 可以方便地修改日期格式
 		String years = dateFormat.format(date);
 		int years_value = Integer.parseInt(years);
 		years_value--;
 		return years_value + "-1-1";
 	}
//    public static void main(String[] args) {
//		Integer i = toInteger(getCurrentDate());
//		System.out.println(i.toString());
//		System.out.println("===========");
//		Date d = toDate(new Integer(20141001));
//		String dd = getDateTime(d,"yyyy-MM-dd");
//		Date ddd = parse(dd, "yyyy-MM-dd");
//		System.out.println(ddd.toString());
 	
 	
 	/*System.out.println("获取当天日期:" + getNowTime("yyyy-MM-dd"));
	System.out.println("获取本月第一天日期:" + getFirstDayOfMonth());
	System.out.println("获取本月最后一天日期:" + getDefaultDay());
	System.out.println("获取上月第一天日期:" + getPreviousMonthFirst());
	System.out.println("获取上月最后一天的日期:" + getPreviousMonthEnd());
	System.out.println("获取下月第一天日期:" + getNextMonthFirst());
	System.out.println("获取下月最后一天日期:" + getNextMonthEnd());
	System.out.println("获取本年的第一天日期:" + getCurrentYearFirst());
	System.out.println("获取本年最后一天日期:" + getCurrentYearEnd());
	System.out.println("获取去年的第一天日期:" + getPreviousYearFirst());
	System.out.println("获取明年第一天日期:" + getNextYearFirst());
	System.out.println("获取明年最后一天日期:" + getNextYearEnd());
	System.out.println("获取两个日期之间间隔天数2008-12-1~2008-9.29:"
			+ DateUtil.getTwoDay("2008-12-1", "2008-9-29"));*/
//	}
}
